home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / gepackte_disketten / 1994 / 08_94_5.dms / 08_94_5.adf / term-4.0-Source.lha / termXEM.c < prev    next >
C/C++ Source or Header  |  1994-07-01  |  23KB  |  1,220 lines
  1. /*
  2. **    termXEM.c
  3. **
  4. **    External emulation support routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* GetOptionMode(struct xpr_option *Option):
  13.      *
  14.      *    Turn text into a boolean value.
  15.      */
  16.  
  17. STATIC BYTE __regargs
  18. GetOptionMode(struct xem_option *Option)
  19. {
  20.     if(Option)
  21.     {
  22.         STATIC STRPTR TrueOptions[] =
  23.         {
  24.             "ON",
  25.             "TRUE",
  26.             "T",
  27.             "YES",
  28.             "Y",
  29.             NULL
  30.         };
  31.  
  32.         register WORD i;
  33.  
  34.         for(i = 0 ; TrueOptions[i] ; i++)
  35.         {
  36.             if(!Stricmp(Option -> xemo_value,TrueOptions[i]))
  37.                 return(TRUE);
  38.         }
  39.     }
  40.  
  41.     return(FALSE);
  42. }
  43.  
  44. STATIC LONG __saveds __asm
  45. xem_sflush(VOID)
  46. {
  47.     if(WriteRequest)
  48.     {
  49.         WriteRequest -> IOSer . io_Command = CMD_CLEAR;
  50.  
  51.         if(!DoIO(WriteRequest))
  52.             return(0);
  53.     }
  54.  
  55.     return(-1);
  56. }
  57.  
  58. STATIC LONG __saveds __asm
  59. xem_squery(VOID)
  60. {
  61.     if(WriteRequest)
  62.     {
  63.         WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  64.  
  65.         DoIO(WriteRequest);
  66.  
  67.             /* Return error if carrier is lost. */
  68.  
  69.         if((WriteRequest -> io_Status & CIAF_COMCD) && Config -> SerialConfig -> CheckCarrier)
  70.             Online = FALSE;
  71.         else
  72.             return((LONG)WriteRequest -> IOSer . io_Actual);
  73.     }
  74.  
  75.     return(-1);
  76. }
  77.  
  78. STATIC LONG __saveds __asm
  79. xem_sread(register __a0 APTR Buffer,register __d0 LONG Size,register __d1 ULONG Timeout)
  80. {
  81.         /* Are both IORequests available? */
  82.  
  83.     if(WriteRequest && ReadRequest)
  84.     {
  85.             /* Valid size parameter? */
  86.  
  87.         if(Size > 0)
  88.         {
  89.                 /* How many bytes are still in the serial buffer? */
  90.  
  91.             WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  92.  
  93.             DoIO(WriteRequest);
  94.  
  95.                 /* Return error if carrier is lost. */
  96.  
  97.             if(Config -> SerialConfig -> CheckCarrier)
  98.             {
  99.                 if(WriteRequest -> io_Status & CIAF_COMCD)
  100.                 {
  101.                     Online = FALSE;
  102.  
  103.                     return(-1);
  104.                 }
  105.             }
  106.  
  107.             /* ALWAYS */
  108.             {
  109.                 register ULONG Waiting;
  110.  
  111.                 if(Waiting = WriteRequest -> IOSer . io_Actual)
  112.                 {
  113.                         /* No timeout specified? Read as many
  114.                          * bytes as available.
  115.                          */
  116.  
  117.                     if(!Timeout)
  118.                     {
  119.                         if(Waiting > Size)
  120.                             Waiting = Size;
  121.  
  122.                         ReadRequest -> IOSer . io_Command    = CMD_READ;
  123.                         ReadRequest -> IOSer . io_Data        = Buffer;
  124.                         ReadRequest -> IOSer . io_Length    = Waiting;
  125.  
  126.                         if(DoIO(ReadRequest))
  127.                             Waiting = ReadRequest -> IOSer . io_Actual;
  128.  
  129.                         BytesIn += Waiting;
  130.  
  131.                         return((LONG)Waiting);
  132.                     }
  133.  
  134.                         /* Enough data pending to be read? */
  135.  
  136.                     if(Waiting >= Size)
  137.                     {
  138.                         ReadRequest -> IOSer . io_Command    = CMD_READ;
  139.                         ReadRequest -> IOSer . io_Data        = Buffer;
  140.                         ReadRequest -> IOSer . io_Length    = Size;
  141.  
  142.                         if(DoIO(ReadRequest))
  143.                             Size = ReadRequest -> IOSer . io_Actual;
  144.  
  145.                         BytesIn += Size;
  146.  
  147.                         return(Size);
  148.                     }
  149.                 }
  150.                 else
  151.                 {
  152.                         /* No timeout & no bytes available:
  153.                          * return immediately.
  154.                          */
  155.  
  156.                     if(!Timeout)
  157.                         return(0);
  158.                 }
  159.             }
  160.  
  161.             /* ALWAYS */
  162.             {
  163.                 register ULONG SignalSet;
  164.  
  165.                     /* Set up the timer. */
  166.  
  167.                 TimeRequest -> tr_node . io_Command    = TR_ADDREQUEST;
  168.                 TimeRequest -> tr_time . tv_secs    = Timeout / MILLION;
  169.                 TimeRequest -> tr_time . tv_micro    = Timeout % MILLION;
  170.  
  171.                     /* Set up the read request. */
  172.  
  173.                 ReadRequest -> IOSer . io_Command    = CMD_READ;
  174.                 ReadRequest -> IOSer . io_Data        = Buffer;
  175.                 ReadRequest -> IOSer . io_Length    = Size;
  176.  
  177.                     /* Prevent early termination. */
  178.  
  179.                 ClrSignal(SIG_SERIAL | SIG_TIMER);
  180.  
  181.                     /* Start IO... */
  182.  
  183.                 SendIO(ReadRequest);
  184.                 SendIO(TimeRequest);
  185.  
  186.                 FOREVER
  187.                 {
  188.                     SignalSet = Wait(SIG_SERIAL | SIG_TIMER);
  189.  
  190.                         /* Receive buffer filled? */
  191.  
  192.                     if(SignalSet & SIG_SERIAL)
  193.                     {
  194.                             /* Abort the timer request. */
  195.  
  196.                         if(!CheckIO(TimeRequest))
  197.                             AbortIO(TimeRequest);
  198.  
  199.                         WaitIO(TimeRequest);
  200.  
  201.                             /* Did the request terminate gracefully? */
  202.  
  203.                         if(WaitIO(ReadRequest))
  204.                             Size = ReadRequest -> IOSer . io_Actual;
  205.  
  206.                         BytesIn += Size;
  207.  
  208.                         return(Size);
  209.                     }
  210.  
  211.                         /* Hit by timeout? */
  212.  
  213.                     if(SignalSet & SIG_TIMER)
  214.                     {
  215.                             /* Abort the read request. */
  216.  
  217.                         if(!CheckIO(ReadRequest))
  218.                             AbortIO(ReadRequest);
  219.  
  220.                         WaitIO(ReadRequest);
  221.  
  222.                             /* Remove the timer request. */
  223.  
  224.                         WaitIO(TimeRequest);
  225.  
  226.                             /* Did the driver receive any
  227.                              * data?
  228.                              */
  229.  
  230.                         if(ReadRequest -> IOSer . io_Actual)
  231.                         {
  232.                             BytesIn += ReadRequest -> IOSer . io_Actual;
  233.  
  234.                             return((LONG)ReadRequest -> IOSer . io_Actual);
  235.                         }
  236.                         else
  237.                         {
  238.                                 /* Take a second look and query the number of
  239.                                  * bytes ready to be received, there may
  240.                                  * still be some bytes in the buffer.
  241.                                  * Note: this depends on the way the
  242.                                  * driver handles read abort.
  243.                                  */
  244.  
  245.                             WriteRequest -> IOSer . io_Command = SDCMD_QUERY;
  246.  
  247.                             DoIO(WriteRequest);
  248.  
  249.                                 /* Don't read too much. */
  250.  
  251.                             if(Size > WriteRequest -> IOSer . io_Actual)
  252.                                 Size = WriteRequest -> IOSer . io_Actual;
  253.  
  254.                                 /* Are there any bytes to be transferred? */
  255.  
  256.                             if(Size)
  257.                             {
  258.                                     /* Read the data. */
  259.  
  260.                                 ReadRequest -> IOSer . io_Command    = CMD_READ;
  261.                                 ReadRequest -> IOSer . io_Data        = Buffer;
  262.                                 ReadRequest -> IOSer . io_Length    = Size;
  263.  
  264.                                     /* Read the data. */
  265.  
  266.                                 if(DoIO(ReadRequest))
  267.                                     Size = ReadRequest -> IOSer . io_Actual;
  268.  
  269.                                 BytesIn += Size;
  270.                             }
  271.  
  272.                             return(Size);
  273.                         }
  274.                     }
  275.                 }
  276.             }
  277.         }
  278.         else
  279.             return(0);
  280.     }
  281.     else
  282.         return(-1);
  283. }
  284.  
  285. STATIC ULONG __saveds __asm
  286. xem_toptions(register __d0 LONG NumOpts,register __a0 struct xem_option **Opts)
  287. {
  288.     if(NumOpts && Opts)
  289.     {
  290.         enum    {    GAD_USE=1,GAD_CANCEL,GAD_SPECIAL };
  291.  
  292.         struct LayoutHandle    *Handle;
  293.         ULONG             Flags = NULL;
  294.  
  295.             /* We only have 32 bits! */
  296.  
  297.         if(NumOpts > 32)
  298.             NumOpts = 32;
  299.  
  300.         if(Handle = LT_CreateHandleTags(Window -> WScreen,
  301.             LH_LocaleHook,    &LocaleHook,
  302.         TAG_DONE))
  303.         {
  304.             struct Window    *Window;
  305.             LONG         i,Split;
  306.  
  307.             if(NumOpts > 16)
  308.                 Split = NumOpts / 2;
  309.             else
  310.                 Split = -1;
  311.  
  312.             LT_New(Handle,
  313.                 LA_Type,    VERTICAL_KIND,
  314.             TAG_DONE);
  315.             {
  316.                 LT_New(Handle,
  317.                     LA_Type,    HORIZONTAL_KIND,
  318.                     LA_LabelID,    MSG_V36_1501,
  319.                 TAG_DONE);
  320.                 {
  321.                     LT_New(Handle,
  322.                         LA_Type,    VERTICAL_KIND,
  323.                     TAG_DONE);
  324.                     {
  325.                         for(i = 0 ; i < NumOpts ; i++)
  326.                         {
  327.                             if(Opts[i])
  328.                             {
  329.                                 switch(Opts[i] -> xemo_type)
  330.                                 {
  331.                                     case XEMO_BOOLEAN:
  332.  
  333.                                         LT_New(Handle,
  334.                                             LA_Type,    CHECKBOX_KIND,
  335.                                             LA_LabelText,    Opts[i] -> xemo_description,
  336.                                             LA_ID,        GAD_SPECIAL + i,
  337.                                             GTCB_Checked,    GetOptionMode(Opts[i]),
  338.                                         TAG_DONE);
  339.  
  340.                                         break;
  341.  
  342.                                     case XEMO_LONG:
  343.  
  344.                                         LT_New(Handle,
  345.                                             LA_Type,        INTEGER_KIND,
  346.                                             LA_LabelText,        Opts[i] -> xemo_description,
  347.                                             LA_ID,            GAD_SPECIAL + i,
  348.                                             LA_Chars,        20,
  349.                                             GTIN_Number,        Atol(Opts[i] -> xemo_value),
  350.                                             LAIN_UseIncrementers,    TRUE,
  351.                                         TAG_DONE);
  352.  
  353.                                         break;
  354.  
  355.                                     case XEMO_STRING:
  356.  
  357.                                         LT_New(Handle,
  358.                                             LA_Type,    STRING_KIND,
  359.                                             LA_LabelText,    Opts[i] -> xemo_description,
  360.                                             LA_ID,        GAD_SPECIAL + i,
  361.                                             LA_Chars,    20,
  362.                                             GTST_String,    Opts[i] -> xemo_value,
  363.                                             GTST_MaxChars,    Opts[i] -> xemo_length - 1,
  364.                                         TAG_DONE);
  365.  
  366.                                         break;
  367.  
  368.                                     case XEMO_COMMPAR:
  369.  
  370.                                         LT_New(Handle,
  371.                                             LA_Type,    STRING_KIND,
  372.                                             LA_LabelText,    Opts[i] -> xemo_description,
  373.                                             LA_ID,        GAD_SPECIAL + i,
  374.                                             LA_Chars,    20,
  375.                                             LA_HighLabel,    TRUE,
  376.                                             GTST_String,    Opts[i] -> xemo_value,
  377.                                             GTST_MaxChars,    Opts[i] -> xemo_length - 1,
  378.                                         TAG_DONE);
  379.  
  380.                                         break;
  381.  
  382.                                     case XEMO_HEADER:
  383.  
  384.                                         LT_New(Handle,
  385.                                             LA_Type,    TEXT_KIND,
  386.                                             LA_LabelText,    Opts[i] -> xemo_description,
  387.                                             LA_HighLabel,    TRUE,
  388.                                             GTTX_Text,    " ",
  389.                                         TAG_DONE);
  390.  
  391.                                         break;
  392.  
  393.                                     case XEMO_COMMAND:
  394.  
  395.                                         LT_New(Handle,
  396.                                             LA_Type,    BUTTON_KIND,
  397.                                             LA_LabelText,    Opts[i] -> xemo_description,
  398.                                             LA_ID,        GAD_SPECIAL + i,
  399.                                             LA_Chars,    20,
  400.                                         TAG_DONE);
  401.  
  402.                                         break;
  403.                                 }
  404.                             }
  405.  
  406.                             if(i == Split)
  407.                             {
  408.                                 LT_EndGroup(Handle);
  409.  
  410.                                 LT_New(Handle,
  411.                                     LA_Type,    VERTICAL_KIND,
  412.                                 TAG_DONE);
  413.                             }
  414.                         }
  415.  
  416.                         LT_EndGroup(Handle);
  417.                     }
  418.  
  419.                     LT_EndGroup(Handle);
  420.                 }
  421.  
  422.                 LT_New(Handle,
  423.                     LA_Type,    VERTICAL_KIND,
  424.                 TAG_DONE);
  425.                 {
  426.                     LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  427.     
  428.                     LT_EndGroup(Handle);
  429.                 }
  430.  
  431.                 LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  432.                     LAGR_SameSize,    TRUE,
  433.                     LAGR_Spread,    TRUE,
  434.                 TAG_DONE);
  435.                 {
  436.                     LT_New(Handle,
  437.                         LA_Type,    BUTTON_KIND,
  438.                         LA_LabelID,    MSG_GLOBAL_USE_GAD,
  439.                         LA_ID,        GAD_USE,
  440.                         LABT_ReturnKey,    TRUE,
  441.                         LABT_ExtraFat,    TRUE,
  442.                     TAG_DONE);
  443.  
  444.                     LT_New(Handle,
  445.                         LA_Type,    BUTTON_KIND,
  446.                         LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  447.                         LA_ID,        GAD_CANCEL,
  448.                         LABT_EscKey,    TRUE,
  449.                         LABT_ExtraFat,    TRUE,
  450.                     TAG_DONE);
  451.  
  452.                     LT_EndGroup(Handle);
  453.                 }
  454.  
  455.                 LT_EndGroup(Handle);
  456.             }
  457.  
  458.             if(Window = LT_Layout(Handle,OptionTitle ? OptionTitle : LocaleString(MSG_V36_1840),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  459.                 LAWN_HelpHook,        &GuideHook,
  460.                 WA_DepthGadget,        TRUE,
  461.                 WA_CloseGadget,        TRUE,
  462.                 WA_DragBar,        TRUE,
  463.                 WA_RMBTrap,        TRUE,
  464.                 WA_Activate,        TRUE,
  465.             TAG_DONE))
  466.             {
  467.                 struct IntuiMessage    *Message;
  468.                 BOOLEAN             Done = FALSE;
  469.                 ULONG             MsgClass,
  470.                              MsgQualifier;
  471.                 UWORD             MsgCode;
  472.                 struct Gadget        *MsgGadget;
  473.                 BOOLEAN             CheckFlags = FALSE;
  474.  
  475.                 PushWindow(Window);
  476.  
  477.                 LT_ShowWindow(Handle,TRUE);
  478.  
  479.                 do
  480.                 {
  481.                     if(Wait(PORTMASK(Window -> UserPort) | SIG_BREAK) & SIG_BREAK)
  482.                         break;
  483.  
  484.                     while(Message = (struct IntuiMessage *)GT_GetIMsg(Window -> UserPort))
  485.                     {
  486.                         MsgClass    = Message -> Class;
  487.                         MsgQualifier    = Message -> Qualifier;
  488.                         MsgCode        = Message -> Code;
  489.                         MsgGadget    = (struct Gadget *)Message -> IAddress;
  490.  
  491.                         GT_ReplyIMsg(Message);
  492.  
  493.                         LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  494.  
  495.                         if(MsgClass == IDCMP_CLOSEWINDOW)
  496.                             Done = TRUE;
  497.  
  498.                         if(MsgClass == IDCMP_GADGETUP)
  499.                         {
  500.                             switch(MsgGadget -> GadgetID)
  501.                             {
  502.                                 case GAD_USE:
  503.  
  504.                                     Done = CheckFlags = TRUE;
  505.                                     break;
  506.  
  507.                                 case GAD_CANCEL:
  508.  
  509.                                     Done = TRUE;
  510.                                     break;
  511.  
  512.                                 default:
  513.  
  514.                                     if(MsgGadget -> GadgetID - GAD_SPECIAL < NumOpts)
  515.                                     {
  516.                                         i = MsgGadget -> GadgetID - GAD_SPECIAL;
  517.  
  518.                                         if(Opts[i] -> xemo_type == XEMO_COMMAND || (Opts[i] -> xemo_type == XEMO_COMMPAR && MsgCode != '\t'))
  519.                                         {
  520.                                             Flags = (1L << i);
  521.  
  522.                                             Done = CheckFlags = TRUE;
  523.                                         }
  524.                                     }
  525.  
  526.                                     break;
  527.                             }
  528.                         }
  529.                     }
  530.                 }
  531.                 while(!Done);
  532.  
  533.                 PopWindow();
  534.  
  535.                 if(CheckFlags)
  536.                 {
  537.                     LT_LockWindow(Window);
  538.  
  539.                     for(i = 0 ; i < NumOpts ; i++)
  540.                     {
  541.                         if(Opts[i])
  542.                         {
  543.                             switch(Opts[i] -> xemo_type)
  544.                             {
  545.                                 case XEMO_BOOLEAN:
  546.  
  547.                                     if(LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE) != GetOptionMode(Opts[i]))
  548.                                     {
  549.                                         Flags |= (1L << i);
  550.  
  551.                                         if(LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE))
  552.                                             strcpy(Opts[i] -> xemo_value,"yes");
  553.                                         else
  554.                                             strcpy(Opts[i] -> xemo_value,"no");
  555.                                     }
  556.  
  557.                                     break;
  558.  
  559.                                 case XEMO_LONG:
  560.  
  561.                                     if(Atol(Opts[i] -> xemo_value) != LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE))
  562.                                     {
  563.                                         Flags |= (1L << i);
  564.  
  565.                                         SPrintf(Opts[i] -> xemo_value,"%ld",LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE));
  566.                                     }
  567.  
  568.                                     break;
  569.  
  570.                                 case XEMO_COMMPAR:
  571.                                 case XEMO_STRING:
  572.  
  573.                                     if(strcmp(Opts[i] -> xemo_value,(STRPTR)LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE)))
  574.                                     {
  575.                                         Flags |= (1L << i);
  576.  
  577.                                         strcpy(Opts[i] -> xemo_value,(STRPTR)LT_GetAttributes(Handle,GAD_SPECIAL + i,TAG_DONE));
  578.                                     }
  579.  
  580.                                     break;
  581.                             }
  582.                         }
  583.                     }
  584.  
  585.                     LT_UnlockWindow(Window);
  586.                 }
  587.                 else
  588.                     Flags = NULL;
  589.             }
  590.  
  591.             LT_DeleteHandle(Handle);
  592.         }
  593.  
  594.         return(Flags);
  595.     }
  596.     else
  597.         return(NULL);
  598. }
  599.  
  600.     /* xem_swrite():
  601.      *
  602.      *    Send a few bytes across the serial line.
  603.      */
  604.  
  605. STATIC LONG __saveds __asm
  606. xem_swrite(register __a0 STRPTR Buffer,register __d0 LONG Size)
  607. {
  608.     if(WriteRequest)
  609.     {
  610.         SerWrite(Buffer,Size);
  611.  
  612.         return(0);
  613.     }
  614.     else
  615.         return(-1);
  616. }
  617.  
  618.     /* xem_sbreak():
  619.      *
  620.      *    Send a break signal across the serial line.
  621.      */
  622.  
  623. STATIC LONG __asm __saveds
  624. xem_sbreak(VOID)
  625. {
  626.     if(!WriteRequest)
  627.         return(-1);
  628.     else
  629.     {
  630.         SendBreak();
  631.  
  632.         return(0);
  633.     }
  634. }
  635.  
  636.     /* xem_sstart():
  637.      *
  638.      *    Restart serial read activity.
  639.      */
  640.  
  641. STATIC VOID __asm __saveds
  642. xem_sstart(VOID)
  643. {
  644.     RestartSerial(FALSE);
  645. }
  646.  
  647.     /* xem_sstop():
  648.      *
  649.      *    Stop serial read activity.
  650.      */
  651.  
  652. STATIC LONG __asm __saveds
  653. xem_sstop(VOID)
  654. {
  655.     if(ReadRequest)
  656.     {
  657.         if(!CheckIO(ReadRequest))
  658.             AbortIO(ReadRequest);
  659.  
  660.         WaitIO(ReadRequest);
  661.     }
  662.  
  663.     return(0);
  664. }
  665.  
  666.     /* xem_tgets(STRPTR Prompt,STRPTR Buffer,ULONG Size):
  667.      *
  668.      *    Get a string from the user.
  669.      */
  670.  
  671. STATIC LONG __saveds __asm
  672. xem_tgets(register __a0 STRPTR Prompt,register __a1 STRPTR Buffer,register __d0 ULONG Size)
  673. {
  674.     enum    {    GAD_OK=1,GAD_CANCEL,GAD_STRING };
  675.  
  676.     struct LayoutHandle    *Handle;
  677.     LONG             Success = FALSE;
  678.     UBYTE             LocalBuffer[256];
  679.  
  680.     if(strlen(Buffer) > 255)
  681.     {
  682.         CopyMem(Buffer,LocalBuffer,255);
  683.  
  684.         LocalBuffer[255] = 0;
  685.     }
  686.     else
  687.         strcpy(LocalBuffer,Buffer);
  688.  
  689.     if(!Prompt)
  690.         Prompt = LocaleString(MSG_TERMXPR_INPUT_REQUIRED_TXT);
  691.  
  692.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  693.         LH_LocaleHook,    &LocaleHook,
  694.     TAG_DONE))
  695.     {
  696.         struct Window *Window;
  697.  
  698.         LT_New(Handle,
  699.             LA_Type,    VERTICAL_KIND,
  700.         TAG_DONE);
  701.         {
  702.             LT_New(Handle,
  703.                 LA_Type,    VERTICAL_KIND,
  704.                 LA_LabelText,    Prompt,
  705.             TAG_DONE);
  706.             {
  707.                 LT_New(Handle,
  708.                     LA_Type,    STRING_KIND,
  709.                     LA_STRPTR,    LocalBuffer,
  710.                     LA_Chars,    30,
  711.                     GTST_MaxChars,    Size,
  712.                 TAG_DONE);
  713.  
  714.                 LT_EndGroup(Handle);
  715.             }
  716.  
  717.             LT_New(Handle,
  718.                 LA_Type,VERTICAL_KIND,
  719.             TAG_DONE);
  720.             {
  721.                 LT_New(Handle,
  722.                     LA_Type,    XBAR_KIND,
  723.                     LAXB_FullSize,    TRUE,
  724.                 TAG_DONE);
  725.  
  726.                 LT_EndGroup(Handle);
  727.             }
  728.  
  729.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  730.                 LAGR_SameSize,    TRUE,
  731.                 LAGR_Spread,    TRUE,
  732.             TAG_DONE);
  733.             {
  734.                 LT_New(Handle,
  735.                     LA_Type,    BUTTON_KIND,
  736.                     LA_LabelID,    MSG_TERMXPR_OKAY_GAD,
  737.                     LA_ID,        GAD_OK,
  738.                     LABT_ReturnKey,    TRUE,
  739.                     LABT_ExtraFat,    TRUE,
  740.                 TAG_DONE);
  741.  
  742.                 LT_New(Handle,
  743.                     LA_Type,    BUTTON_KIND,
  744.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  745.                     LA_ID,        GAD_CANCEL,
  746.                     LABT_EscKey,    TRUE,
  747.                     LABT_ExtraFat,    TRUE,
  748.                 TAG_DONE);
  749.  
  750.                 LT_EndGroup(Handle);
  751.             }
  752.         }
  753.  
  754.         if(Window = LT_Layout(Handle,LocaleString(MSG_GLOBAL_ENTER_TEXT_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  755.             LAWN_HelpHook,        &GuideHook,
  756.             WA_DepthGadget,        TRUE,
  757.             WA_CloseGadget,        TRUE,
  758.             WA_DragBar,        TRUE,
  759.             WA_RMBTrap,        TRUE,
  760.             WA_Activate,        TRUE,
  761.         TAG_DONE))
  762.         {
  763.             struct IntuiMessage    *Message;
  764.             BOOLEAN             Done = FALSE;
  765.             ULONG             MsgClass,
  766.                          MsgQualifier;
  767.             UWORD             MsgCode;
  768.             struct Gadget        *MsgGadget;
  769.  
  770.             PushWindow(Window);
  771.  
  772.             LT_ShowWindow(Handle,TRUE);
  773.  
  774.             LT_Activate(Handle,GAD_STRING);
  775.  
  776.             do
  777.             {
  778.                 if(Wait(PORTMASK(Window -> UserPort) | SIG_BREAK) & SIG_BREAK)
  779.                     break;
  780.  
  781.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(Window -> UserPort))
  782.                 {
  783.                     MsgClass    = Message -> Class;
  784.                     MsgQualifier    = Message -> Qualifier;
  785.                     MsgCode        = Message -> Code;
  786.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  787.  
  788.                     GT_ReplyIMsg(Message);
  789.  
  790.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  791.  
  792.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  793.                         Done = TRUE;
  794.  
  795.                     if(MsgClass == IDCMP_GADGETUP)
  796.                     {
  797.                         switch(MsgGadget -> GadgetID)
  798.                         {
  799.                             case GAD_STRING:
  800.  
  801.                                 if(MsgCode == '\r')
  802.                                 {
  803.                                     strcpy(Buffer,LocalBuffer);
  804.  
  805.                                     Success = Done = TRUE;
  806.  
  807.                                     LT_PressButton(Handle,GAD_OK);
  808.                                 }
  809.  
  810.                                 break;
  811.  
  812.                             case GAD_OK:
  813.  
  814.                                 strcpy(Buffer,LocalBuffer);
  815.  
  816.                                 Success = Done = TRUE;
  817.                                 break;
  818.  
  819.                             case GAD_CANCEL:
  820.  
  821.                                 Done = TRUE;
  822.                                 break;
  823.                         }
  824.                     }
  825.                 }
  826.             }
  827.             while(!Done);
  828.  
  829.             PopWindow();
  830.         }
  831.  
  832.         LT_DeleteHandle(Handle);
  833.     }
  834.  
  835.     return(Success);
  836. }
  837.  
  838.     /* xem_tbeep(ULONG Times,ULONG Delay):
  839.      *
  840.      *    Beep the terminal display.
  841.      */
  842.  
  843. STATIC VOID __saveds __asm
  844. xem_tbeep(register __d0 ULONG Times,register __d1 ULONG Delay)
  845. {
  846.     WORD i;
  847.  
  848.     for(i = 0 ; i < Times ; i++)
  849.     {
  850.             /* Handle the visual part. */
  851.  
  852.         if(Config -> TerminalConfig -> BellMode != BELL_AUDIBLE)
  853.         {
  854.             if(StatusProcess)
  855.                 Signal(StatusProcess,SIG_BELL);
  856.         }
  857.  
  858.             /* Let it beep. */
  859.  
  860.         if(Config -> TerminalConfig -> BellMode == BELL_AUDIBLE || Config -> TerminalConfig -> BellMode == BELL_BOTH)
  861.             SoundPlay(SOUND_BELL);
  862.     }
  863. }
  864.  
  865.     /* xem_macrodispatch(struct XEmulatorMacroKey *XEM_MacroKey):
  866.      *
  867.      *    Dispatch a macro key call.
  868.      */
  869.  
  870. STATIC LONG __saveds __asm
  871. xem_macrodispatch(register __a0 struct XEmulatorMacroKey *XEM_MacroKey)
  872. {
  873.     VOID (*Routine)(VOID);
  874.  
  875.         /* If a routine to call is available (most likely xON or xOFF),
  876.          * make a call to it, else process the macro key data.
  877.          */
  878.  
  879.     if(Routine = (VPTR)XEM_MacroKey -> xmk_UserData)
  880.         (*Routine)();
  881.     else
  882.         SerialCommand(MacroKeys -> Keys[XEM_MacroKey -> xmk_Qualifier][XEM_MacroKey -> xmk_Code - 0x50]);
  883.  
  884.     return(0);
  885. }
  886.  
  887.     /* SetEmulatorOptions(BYTE Mode):
  888.      *
  889.      *    Save or load the emulator options.
  890.      */
  891.  
  892. BYTE __regargs
  893. SetEmulatorOptions(BYTE Mode)
  894. {
  895.     BYTE Success = FALSE;
  896.  
  897.         /* Is the library available and running? */
  898.  
  899.     if(XEmulatorBase && XEM_IO)
  900.     {
  901.             /* Are we using the new library code? */
  902.  
  903.         if(XEmulatorBase -> lib_Version >= 4)
  904.         {
  905.                 /* Get the name of the library. */
  906.  
  907.             strcpy(SharedBuffer,FilePart(XEmulatorBase -> lib_Node . ln_Name));
  908.  
  909.                 /* Does it have any name? */
  910.  
  911.             if(SharedBuffer[0])
  912.             {
  913.                 UBYTE    OtherBuffer[50];
  914.                 WORD    i;
  915.  
  916.                     /* Strip the `.library' bit. */
  917.  
  918.                 for(i = strlen(SharedBuffer) - 1 ; i >= 0 ; i--)
  919.                 {
  920.                     if(SharedBuffer[i] == '.')
  921.                     {
  922.                         SharedBuffer[i] = 0;
  923.  
  924.                         break;
  925.                     }
  926.                 }
  927.  
  928.                     /* What are we to do? */
  929.  
  930.                 if(Mode == XEM_PREFS_LOAD)
  931.                 {
  932.                         /* Restore settings... */
  933.  
  934.                     strcpy(OtherBuffer,"ENV:");
  935.  
  936.                     if(AddPart(OtherBuffer,SharedBuffer,50))
  937.                     {
  938.                             /* If we can't load them,
  939.                              * reset to defaults.
  940.                              */
  941.  
  942.                         if(!XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  943.                         {
  944.                             strcpy(OtherBuffer,"ENV:xem");
  945.  
  946.                             if(AddPart(OtherBuffer,SharedBuffer,50))
  947.                             {
  948.                                 if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  949.                                     Success = TRUE;
  950.                             }
  951.                         }
  952.                         else
  953.                             Success = TRUE;
  954.  
  955.                         if(!Success)
  956.                             XEmulatorPreferences(XEM_IO,NULL,XEM_PREFS_RESET);
  957.                     }
  958.                 }
  959.                 else
  960.                 {
  961.                         /* Save settings to ENV: */
  962.  
  963.                     strcpy(OtherBuffer,"ENV:");
  964.  
  965.                     if(AddPart(OtherBuffer,SharedBuffer,50))
  966.                     {
  967.                         if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  968.                             Success = TRUE;
  969.                     }
  970.  
  971.                     if(Success)
  972.                     {
  973.                         Success = FALSE;
  974.  
  975.                             /* Save settings to ENVARC: */
  976.  
  977.                         strcpy(OtherBuffer,"ENVARC:");
  978.  
  979.                         if(AddPart(OtherBuffer,SharedBuffer,50))
  980.                         {
  981.                             if(XEmulatorPreferences(XEM_IO,OtherBuffer,Mode))
  982.                                 Success = TRUE;
  983.                         }
  984.                     }
  985.                 }
  986.             }
  987.         }
  988.     }
  989.  
  990.         /* Return result. */
  991.  
  992.     return(Success);
  993. }
  994.  
  995.     /* SetupEmulator(BYTE OpenConsole):
  996.      *
  997.      *    Initialize the XEM_IO structure.
  998.      */
  999.  
  1000. STATIC BYTE
  1001. SetupEmulator(VOID)
  1002. {
  1003.     if(!XEM_IO)
  1004.     {
  1005.         if(XEM_IO = (struct XEM_IO *)AllocVec(sizeof(struct XEM_IO),MEMF_ANY | MEMF_CLEAR | MEMF_PUBLIC))
  1006.         {
  1007.             XEM_IO -> xem_window        = Window;
  1008.             XEM_IO -> xem_font        = CurrentFont;
  1009.             XEM_IO -> xem_signal        = &XEM_Signal;
  1010.             XEM_IO -> xem_screendepth    = Window -> WScreen -> RastPort . BitMap -> Depth;
  1011.  
  1012.             XEM_IO -> xem_sread        = xem_sread;
  1013.             XEM_IO -> xem_swrite        = xem_swrite;
  1014.             XEM_IO -> xem_sflush        = xem_sflush;
  1015.             XEM_IO -> xem_sbreak        = xem_sbreak;
  1016.             XEM_IO -> xem_squery        = xem_squery;
  1017.             XEM_IO -> xem_sstart        = xem_sstart;
  1018.             XEM_IO -> xem_sstop        = xem_sstop;
  1019.  
  1020.             XEM_IO -> xem_tbeep        = xem_tbeep;
  1021.             XEM_IO -> xem_tgets        = xem_tgets;
  1022.             XEM_IO -> xem_toptions        = xem_toptions;
  1023.  
  1024.             XEM_IO -> xem_process_macrokeys    = xem_macrodispatch;
  1025.  
  1026.             return(TRUE);
  1027.         }
  1028.     }
  1029.     else
  1030.         return(FALSE);
  1031.  
  1032.     return(FALSE);
  1033. }
  1034.  
  1035.     /* CloseEmulator():
  1036.      *
  1037.      *    Close the emulation library.
  1038.      */
  1039.  
  1040. VOID
  1041. CloseEmulator()
  1042. {
  1043.     if(XEmulatorBase)
  1044.     {
  1045.         if(XEM_IO)
  1046.         {
  1047.             XEmulatorMacroKeyFilter(XEM_IO,NULL);
  1048.             XEmulatorCloseConsole(XEM_IO);
  1049.             XEmulatorCleanup(XEM_IO);
  1050.         }
  1051.  
  1052.         CloseLibrary(XEmulatorBase);
  1053.  
  1054.         if(XEM_IO)
  1055.             FreeVec(XEM_IO);
  1056.  
  1057.         strcpy(EmulationName,LocaleString(MSG_TERMXEM_NO_EMULATION_TXT));
  1058.  
  1059.         XEmulatorBase    = NULL;
  1060.         XEM_Signal    = NULL;
  1061.         XEM_IO        = NULL;
  1062.  
  1063.         RasterEnabled = TRUE;
  1064.  
  1065.         ClearCursor();
  1066.  
  1067.         Reset();
  1068.  
  1069.         DrawCursor();
  1070.     }
  1071. }
  1072.  
  1073.     /* OpenEmulator(STRPTR Name):
  1074.      *
  1075.      *    Open an emulation library.
  1076.      */
  1077.  
  1078. BYTE __regargs
  1079. OpenEmulator(STRPTR Name)
  1080. {
  1081.     CloseEmulator();
  1082.  
  1083.     XEM_HostData . Source        = NULL;
  1084.     XEM_HostData . Destination    = NULL;
  1085.     XEM_HostData . InESC        = FALSE;
  1086.     XEM_HostData . InCSI        = FALSE;
  1087.  
  1088.     if(XEmulatorBase = OpenLibrary(Name,0))
  1089.     {
  1090.         ClearCursor();
  1091.  
  1092.         Reset();
  1093.  
  1094.         if(SetupEmulator())
  1095.         {
  1096.             SetWrMsk(RPort,DepthMask);
  1097.  
  1098.             ClearSerial();
  1099.  
  1100.             if(XEmulatorSetup(XEM_IO))
  1101.             {
  1102.                 RestartSerial(FALSE);
  1103.  
  1104.                 SetEmulatorOptions(XEM_PREFS_LOAD);
  1105.  
  1106.                 if(XEmulatorOpenConsole(XEM_IO))
  1107.                 {
  1108.                     STRPTR LibName = FilePart(XEmulatorBase -> lib_Node . ln_Name);
  1109.  
  1110.                     strcpy(EmulationName,&LibName[3]);
  1111.  
  1112.                     EmulationName[strlen(EmulationName) - 8] = 0;
  1113.  
  1114.                     SetupXEM_MacroKeys(MacroKeys);
  1115.  
  1116.                     return(TRUE);
  1117.                 }
  1118.             }
  1119.             else
  1120.                 RestartSerial(FALSE);
  1121.         }
  1122.  
  1123.         DrawCursor();
  1124.  
  1125.         CloseLibrary(XEmulatorBase);
  1126.  
  1127.         strcpy(EmulationName,LocaleString(MSG_TERMXEM_NO_EMULATION_TXT));
  1128.  
  1129.         XEmulatorBase    = NULL;
  1130.         XEM_Signal    = NULL;
  1131.     }
  1132.  
  1133.     return(FALSE);
  1134. }
  1135.  
  1136.     /* XOff():
  1137.      *
  1138.      *    Small local routine, complements XOn() in Serial.c
  1139.      */
  1140.  
  1141. STATIC VOID
  1142. XOff(VOID)
  1143. {
  1144.     if(Status == STATUS_HOLDING)
  1145.     {
  1146.         UBYTE c = XOF;
  1147.  
  1148.         SerWrite(&c,1);
  1149.  
  1150.         Status = STATUS_READY;
  1151.     }
  1152. }
  1153.  
  1154.     /* SetupXEM_MacroKeys(struct MacroKeys *Keys):
  1155.      *
  1156.      *    Sets up the internal representation of the macro key
  1157.      *    data to fit the XEM specification.
  1158.      */
  1159.  
  1160. VOID __regargs
  1161. SetupXEM_MacroKeys(struct MacroKeys *Keys)
  1162. {
  1163.         /* Are we allowed to do what we want to do? */
  1164.  
  1165.     if(XEM_MacroKeys && XEmulatorBase && Config -> TerminalConfig -> EmulationMode == EMULATION_EXTERNAL)
  1166.     {
  1167.         WORD i,j,k = 0;
  1168.  
  1169.             /* Clear the macro list. */
  1170.  
  1171.         NewList(&XEM_MacroList);
  1172.  
  1173.             /* Run down the list of qualifiers. */
  1174.  
  1175.         for(i = XMKQ_NONE ; i <= XMKQ_CONTROL ; i++)
  1176.         {
  1177.                 /* Run down the function keys. */
  1178.  
  1179.             for(j = 0 ; j < 10 ; j++)
  1180.             {
  1181.                     /* If the key has no data attached,
  1182.                      * don't use it in the list.
  1183.                      */
  1184.  
  1185.                 if(Keys -> Keys[i][j][0])
  1186.                 {
  1187.                     XEM_MacroKeys[k] . xmk_Type        = XMKT_RAWKEY;
  1188.                     XEM_MacroKeys[k] . xmk_Qualifier    = i;
  1189.                     XEM_MacroKeys[k] . xmk_Code        = 0x50 + j;
  1190.                     XEM_MacroKeys[k] . xmk_UserData        = NULL;
  1191.  
  1192.                     AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k++]);
  1193.                 }
  1194.             }
  1195.         }
  1196.  
  1197.             /* Take care of the rest, add support for the xON key. */
  1198.  
  1199.         XEM_MacroKeys[k] . xmk_Type         = XMKT_COOKED;
  1200.         XEM_MacroKeys[k] . xmk_Qualifier    = NULL;
  1201.         XEM_MacroKeys[k] . xmk_Code        = XON;
  1202.         XEM_MacroKeys[k] . xmk_UserData        = (APTR)DoxON;
  1203.  
  1204.         AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k++]);
  1205.  
  1206.             /* Take care of the xOFF key. */
  1207.  
  1208.         XEM_MacroKeys[k] . xmk_Type         = XMKT_COOKED;
  1209.         XEM_MacroKeys[k] . xmk_Qualifier    = NULL;
  1210.         XEM_MacroKeys[k] . xmk_Code        = XOF;
  1211.         XEM_MacroKeys[k] . xmk_UserData        = (APTR)XOff;
  1212.  
  1213.         AddTail(&XEM_MacroList,(struct Node *)&XEM_MacroKeys[k]);
  1214.  
  1215.             /* Make the emulator notice the new settings. */
  1216.  
  1217.         XEmulatorMacroKeyFilter(XEM_IO,&XEM_MacroList);
  1218.     }
  1219. }
  1220.